ebab7d0da53c51438720d60c6e2e467c - /page/wikibook/entry.mu

Micron Document

Livres et Wikis | Archives | Info

🔍Search

JavaScript syntax

107.0 KB · ⇊ 30 parts · ⤓ Micron 107.0 KB · ⤓ HTML 322.9 KB

layout: Wide · Narrow · Centered

──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

top

The syntax of JavaScript is the set of rules that define a correctly

structured JavaScript program.

The examples below make use of the console.log() function present in

most browsers for standard text output.

The JavaScript standard library lacks an official standard text output

function (with the exception of document.write). Given that JavaScript

is mainly used for client-side scripting within modern web browsers, and

that almost all Web browsers provide the alert function, alert can also

be used, but is not commonly used.

Contents

• Origins

• Basics

• Case sensitivity

• Whitespace and semicolons

• Comments

• Variables

• Scoping and hoisting

• Declaration and assignment

• Examples

• Primitive data types

• Undefined

• Number

• BigInt

• String

• Boolean

• Type conversion

• Symbol

• Native objects

• Array

• Date

• Error

• Math

• Regular expression

• Function

• Operators

• Arithmetic

• Assignment

• Comparison

• Logical

• Logical assignment

• Bitwise

• Bitwise Assignment

• String

• ??

• Control structures

• Compound statements

• If ... else

• Conditional (ternary) operator

• Switch statement

• For loop

• For ... in loop

• While loop

• Do ... while loop

• With

• Labels

• Functions

• Async/await

• Objects

• Creating objects

• Methods

• Constructors

• Inheritance

• Exception handling

• Native functions and methods

• eval (expression)

• See also

• References

• Further reading

• External links

Origins

Brendan Eich summarized the ancestry of the syntax in the first

paragraph of the JavaScript 1.1 specificationcite-ref-1[1]cite-ref-2[2] as follows:

JavaScript borrows most of its syntax from Java, but also inherits

from Awk and Perl, with some indirect influence from Self in its

object prototype system.

Basics

Case sensitivity

JavaScript is case sensitive. It is common to start the name of a

constructor with a capitalized letter, and the name of a function or

variable with a lower-case letter.

Example:

var a = 5;

console.log(a); // 5

console.log(A); // throws a ReferenceError: A is not defined

Whitespace and semicolons

Unlike in C, whitespace in JavaScript source can directly impact

semantics. Semicolons end statements in JavaScript. Because of

automatic semicolon insertion (ASI), some statements that are well

formed when a newline is parsed will be considered complete, as if a

semicolon were inserted just prior to the newline. Some authorities

advise supplying statement-terminating semicolons explicitly, because it

may lessen unintended effects of the automatic semicolon insertion.cite-ref-3[3]

There are two issues: five tokens can either begin a statement or be the

extension of a complete statement; and five restricted productions,

where line breaks are not allowed in certain positions, potentially

yielding incorrect parsing.

The five problematic tokens are the open parenthesis "(", open bracket

"[", slash "/", plus "+", and minus "-". Of these, the open parenthesis

is common in the immediately invoked function expression pattern, and

open bracket occurs sometimes, while others are quite rare. An example:

a = b + c

(d + e).foo()

// Treated as:

// a = b + c(d + e).foo();

with the suggestion that the preceding statement be terminated with a

semicolon.

Some suggest instead the use of leading semicolons on lines starting

with '(' or '[', so the line is not accidentally joined with the

previous one. This is known as a defensive semicolon, and is

particularly recommended, because code may otherwise become ambiguous

when it is rearranged. For example:

a = b + c

;(d + e).foo()

// Treated as:

// a = b + c;

// (d + e).foo();

Initial semicolons are also sometimes used at the start of JavaScript

libraries, in case they are appended to another library that omits a

trailing semicolon, as this can result in ambiguity of the initial

statement.

The five restricted productions are return, throw, break, continue, and

post-increment/decrement. In all cases, inserting semicolons does not

fix the problem, but makes the parsed syntax clear, making the error

easier to detect. return and throw take an optional value, while break

and continue take an optional label. In all cases, the advice is to keep

the value or label on the same line as the statement. This most often

shows up in the return statement, where one might return a large object

literal, which might be accidentally placed starting on a new line. For

post-increment/decrement, there is potential ambiguity with

pre-increment/decrement, and again it is recommended to simply keep

these on the same line.

return

a + b;

// Returns undefined. Treated as:

// return;

// a + b;

// Should be written as:

// return a + b;

Comments

Comment syntax is the same as in C++, Swift and other programming

languages.

Single-line comments begin with // and continue until the end of the

line. A second type of comments can also be made; these start with /*

and end with */ and can be used for multi-line comments.

A third type of comment, the hashbang comment, starts with #! and

continues until the end of the line. They are only valid at the start of

files and are intended for use in CLI environments.cite-ref-4[4]

#! Hashbang comment

// One-line comment

/* Multi-line

comment */

Variables

Variables in standard JavaScript have no type attached, so any value

(each value has a type) can be stored in any variable. Starting with

ES6, the 6th version of the language, variables could be declared with

var for function scoped variables, and let or const which are for

block level variables. Before ES6, variables could only be declared with

a var statement. Values assigned to variables declared with const cannot

be changed, but their properties can. var should no longer be used since

let and const are supported by modern browsers.cite-ref-5[5] A variable's

identifier must start with a letter, underscore (_), or dollar sign ($),

while subsequent characters can also be digits (0-9). JavaScript is case

sensitive, so the uppercase characters "A" through "Z" are different

from the lowercase characters "a" through "z".

Starting with JavaScript 1.5, ISO 8859-1 or Unicode letters (or \uXXXX

Unicode escape sequences) can be used in identifiers.cite-ref-6[6] In certain

JavaScript implementations, the at sign (@) can be used in an

identifier, but this is contrary to the specifications and not supported

in newer implementations.

Scoping and hoisting

Variables declared with var are lexically scoped at a function level,

while ones with let or const have a block level scope. Since

declarations are processed before any code is executed, a variable can

be assigned to and used prior to being declared in the code.cite-ref-7[7] This is

referred to as hoisting, and it is equivalent to variables being

forward declared at the top of the function or block.cite-ref-8[8]

With var, let, and const statements, only the declaration is hoisted;

assignments are not hoisted. Thus a var x = 1 statement in the middle of

the function is equivalent to a var x declaration statement at the top

of the function, and an x = 1 assignment statement at that point in the

middle of the function. This means that values cannot be accessed before

they are declared; forward reference is not possible. With var a

variable's value is undefined until it is initialized. Variables

declared with let or const cannot be accessed until they have been

initialized, so referencing such variables before will cause an error.

Function declarations, which declare a variable and assign a function to

it, are similar to variable statements, but in addition to hoisting the

declaration, they also hoist the assignment – as if the entire statement

appeared at the top of the containing function – and thus forward

reference is also possible: the location of a function statement within

an enclosing function is irrelevant. This is different from a function

expression being assigned to a variable in a var, let, or const

statement.

So, for example,

var func = function() { .. } // declaration is hoisted only

function func() { .. } // declaration and assignment are hoisted

Block scoping can be produced by wrapping the entire block in a function

and then executing it – this is known as the

immediately-invoked function expression pattern – or by declaring the

variable using the let keyword.

Declaration and assignment

Variables declared outside a scope are global. If a variable is declared

in a higher scope, it can be accessed by child scopes.

When JavaScript tries to resolve an identifier, it looks in the local

scope. If this identifier is not found, it looks in the next outer

scope, and so on along the scope chain until it reaches the global scope

where global variables reside. If it is still not found, JavaScript will

raise a ReferenceError exception.

When assigning an identifier, JavaScript goes through exactly the same

process to retrieve this identifier, except that if it is not found in

the global scope, it will create the "variable" in the scope where it

was created.cite-ref-9[9] As a consequence, a variable never declared will be

global, if assigned. Declaring a variable (with the keyword var) in the

global scope (i.e. outside of any function body (or block in the case of

let/const)), assigning a never declared identifier or adding a property

to the global object (usually window) will also create a new global

variable.

Note that JavaScript's strict mode forbids the assignment of an

undeclared variable, which avoids global namespace pollution.

Examples

Here are some examples of variable declarations and scope:

var x1 = 0; // A global variable, because it is not in any function

let x2 = 0; // Also global, this time because it is not in any block

function f() {

var z = 'foxes', r = 'birds'; // 2 local variables

m = 'fish'; // global, because it was not declared anywhere before

function child() {

var r = 'monkeys'; // This variable is local and does not affect the

"birds" r of the parent function.

z = 'penguins'; // Closure: Child function is able to access the

variables of the parent function.

}

twenty = 20; // This variable is declared on the next line, but usable

anywhere in the function, even before, as here

var twenty;

child();

return x1 + x2; // We can use x1 and x2 here, because they are global

}

f();

console.log(z); // This line will raise a ReferenceError exception,

because the value of z is no longer available

for (let i = 0; i < 10; i++) console.log(i);

console.log(i); // throws a ReferenceError: i is not defined

for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError:

Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception.

i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const

declaration

Primitive data types

The JavaScript language provides six primitive data types:

• Undefined

• Number

• BigInt

• String

• Boolean

• Symbol

Some of the primitive data types also provide a set of named values that

represent the extents of the type boundaries. These named values are

described within the appropriate sections below.

Undefined

The value of "undefined" is assigned to all uninitialized variables, and

is also returned when checking for object properties that do not exist.

In a Boolean context, the undefined value is considered a false value.

Note: undefined is considered a genuine primitive type. Unless

explicitly converted, the undefined value may behave unexpectedly in

comparison to other types that evaluate to false in a logical context.

let test; // variable declared, but not defined, ...

// ... set to value of undefined

const testObj = {};

console.log(test); // test variable exists, but value not ...

// ... defined, displays undefined

console.log(testObj.myProp); // testObj exists, property does not, ...

// ... displays undefined

console.log(undefined == null); // unenforced type during check,

displays true

console.log(undefined === null); // enforce type during check, displays

false

Note: There is no built-in language literal for undefined. Thus (x ===

undefined) is not a foolproof way to check whether a variable is

undefined, because in versions before ECMAScript 5, it is legal for

someone to write var undefined = "I'm defined now";. A more robust

approach is to compare using (typeof x === 'undefined').

Functions like this will not work as expected:

function isUndefined(x) { let u; return x === u; } // like this...

function isUndefined(x) { return x === void 0; } // ... or that second

one

function isUndefined(x) { return (typeof x) === "undefined"; } // ... or

that third one

Here, calling isUndefined(my_var) raises a ReferenceError if my_var is

an unknown identifier, whereas typeof my_var === 'undefined' does not.

Number

Numbers are represented in binary as IEEE 754 floating point doubles.

Although this format provides an accuracy of nearly 16

significant digits, it cannot always exactly represent real numbers,

including fractions.

This becomes an issue when comparing or formatting numbers. For example:

console.log(0.2 + 0.1 === 0.3); // displays false

console.log(0.94 - 0.01); // displays 0.9299999999999999

As a result, a routine such as the toFixed() method should be used to

round numbers whenever they are formatted for output.

Numbers may be specified in any of these notations:

345; // an "integer", although there is only one numeric type in

JavaScript

34.5; // a floating-point number

3.45e2; // another floating-point, equivalent to 345

0b1011; // a binary integer equal to 11

0o377; // an octal integer equal to 255

0xFF; // a hexadecimal integer equal to 255, digits represented by the

...

// ... letters A-F may be upper or lowercase

There is also a numeric separator, _ (the underscore), introduced in

ES2021:

// Note: Wikipedia syntax does not support numeric separators yet

1_000_000_000; // Used with big numbers

1_000_000.5; // Support with decimals

1_000e1_000; // Support with exponents

// Support with binary, octals and hex

0b0000_0000_0101_1011;

0o0001_3520_0237_1327;

0xFFFF_FFFF_FFFF_FFFE;

// But users cannot use them next to a non-digit number part, or at the

start or end

_12; // Variable is not defined (the underscore makes it a variable

identifier)

12_; // Syntax error (cannot be at the end of numbers)

12_.0; // Syntax error (does not make sense to put a separator next to

the decimal point)

12._0; // Syntax error

12e_6; // Syntax error (next to "e", a non-digit. Does not make sense to

put a separator at the start)

1000____0000; // Syntax error (next to "_", a non-digit. Only 1

separator at a time is allowed

The extents +∞, −∞ and NaN (Not a Number) of the number type may be

obtained by two program expressions:

Infinity; // positive infinity (negative obtained with -Infinity for

instance)

NaN; // The Not-A-Number value, also returned as a failure in ...

// ... string-to-number conversions

Infinity and NaN are numbers:

typeof Infinity; // returns "number"

typeof NaN; // returns "number"

These three special values correspond and behave as the IEEE-754

describes them.

The Number constructor (used as a function), or a unary + or -, may be

used to perform explicit numeric conversion:

const myString = "123.456";

const myNumber1 = Number(myString);

const myNumber2 = +myString;

When used as a constructor, a numeric wrapper object is created (though

it is of little use):

const myNumericWrapper = new Number(123.456);

However, NaN is not equal to itself:

const nan = NaN;

console.log(NaN == NaN); // false

console.log(NaN === NaN); // false

console.log(NaN !== NaN); // true

console.log(nan !== nan); // true

// Users can use the isNaN methods to check for NaN

console.log(isNaN("converted to NaN")); // true

console.log(isNaN(NaN)); // true

console.log(Number.isNaN("not converted")); // false

console.log(Number.isNaN(NaN)); // true

BigInt

In JavaScript, regular numbers are represented with the IEEE 754

floating point type, meaning integers can only safely be stored if the

value falls between Number.MIN_SAFE_INTEGER and Number.MAX_SAFE_INTEGER.

cite-ref-10[10] BigInts instead represent integers of any size, allowing

programmers to store integers too high or low to be represented with the

IEEE 754 format.cite-ref-bigint-mdn-11-0[11]

There are two ways to declare a BigInt value. An n can be appended to an

integer, or the BigInt function can be used:cite-ref-bigint-mdn-11-1[11]

const a = 12345n; // Creates a variable and stores a BigInt value of

12345

const b = BigInt(12345);

String

A string in JavaScript is a sequence of characters. In JavaScript,

strings can be created directly (as literals) by placing the series of

characters between double (") or single (') quotes. Such strings must be

written on a single line, but may include escaped newline characters

(such as \n). The JavaScript standard allows the backquote character

(`, a.k.a. grave accent or backtick) to quote multiline literal

strings, as well as embedded expressions using the syntax

${expression}.cite-ref-12[12]

const greeting = "Hello, World!";

const anotherGreeting = 'Greetings, people of Earth.';

const aMultilineGreeting = `Warm regards,

John Doe.`

// Template literals type-coerce evaluated expressions and interpolate

them into the string.

const templateLiteral = `This is what is stored in anotherGreeting:

${anotherGreeting}.`;

console.log(templateLiteral); // 'This is what is stored in

anotherGreeting: 'Greetings, people of Earth.''

console.log(`You are ${Math.floor(age)=>18 ? "allowed" : "not allowed"}

to view this web page`);

Individual characters within a string can be accessed using the charAt

method (provided by String.prototype). This is the preferred way when

accessing individual characters within a string, because it also works

in non-modern browsers:

const h = greeting.charAt(0);

In modern browsers, individual characters within a string can be

accessed (as strings with only a single character) through the same

notation as arrays:

const h = greeting[0];

However, JavaScript strings are immutable:

greeting[0] = "H"; // Fails.

Applying the equality operator ("==") to two strings returns true, if

the strings have the same contents, which means: of the same length and

containing the same sequence of characters (case is significant for

alphabets). Thus:

const x = "World";

const compare1 = ("Hello, " + x == "Hello, World"); // Here compare1

contains true.

const compare2 = ("Hello, " + x == "hello, World"); // Here compare2

contains ...

// ... false since the ...

// ... first characters ...

// ... of both operands ...

// ... are not of the same case.

Quotes of the same type cannot be nested unless they are escaped.

let x = '"Hello, World!" he said.'; // Just fine.

x = ""Hello, World!" he said."; // Not good.

x = "\"Hello, World!\" he said."; // Works by escaping " with \"

The String constructor creates a string object (an object wrapping a

string):

const greeting = new String("Hello, World!");

These objects have a valueOf method returning the primitive string

wrapped within them:

const s = new String("Hello !");

typeof s; // Is 'object'.

typeof s.valueOf(); // Is 'string'.

Equality between two String objects does not behave as with string

primitives:

const s1 = new String("Hello !");

const s2 = new String("Hello !");

s1 == s2; // Is false, because they are two distinct objects.

s1.valueOf() == s2.valueOf(); // Is true.

Boolean

JavaScript provides a Boolean data type with true and false literals.

The typeof operator returns the string "boolean" for these

primitive types. When used in a logical context, 0, -0, null, NaN,

undefined, and the empty string ("") evaluate as false due to automatic

type conversion. All other values (the complement of the previous list)

evaluate as true, including the strings "0", "false" and any object.

Type conversion

Automatic type coercion by the equality comparison operators (== and !=)

can be avoided by using the type checked comparison operators (=== and

!==).

When type conversion is required, JavaScript converts Boolean, Number,

String, or Object operands as follows:cite-ref-13[13]

Number and String

The string is converted to a number value. JavaScript attempts to

convert the string numeric literal to a Number type value. First, a

mathematical value is derived from the string numeric literal. Next,

this value is rounded to nearest Number type value.

Boolean

If one of the operands is a Boolean, the Boolean operand is converted

to 1 if it is true, or to 0 if it is false.

Object

If an object is compared with a number or string, JavaScript attempts

to return the default value for the object. An object is converted to

a primitive String or Number value, using the .valueOf() or

.toString() methods of the object. If this fails, a runtime error is

generated.

Boolean type conversion

Douglas Crockford advocates the terms "truthy" and "falsy" to describe

how values of various types behave when evaluated in a logical context,

especially in regard to edge cases.cite-ref-14[14] The binary logical operators

returned a Boolean value in early versions of JavaScript, but now they

return one of the operands instead. The left–operand is returned, if it

can be evaluated as : false, in the case of conjunction: (a && b), or

true, in the case of disjunction: (a || b); otherwise the right–operand

is returned. Automatic type coercion by the comparison operators may

differ for cases of mixed Boolean and number-compatible operands

(including strings that can be evaluated as a number, or objects that

can be evaluated as such a string), because the Boolean operand will be

compared as a numeric value. This may be unexpected. An expression can

be explicitly cast to a Boolean primitive by doubling the logical

negation operator: (!!), using the Boolean() function, or using the

conditional operator: (c ? t : f).

// Automatic type coercion

console.log(true == 2 ); // false... true → 1 !== 2 ← 2

console.log(false == 2 ); // false... false → 0 !== 2 ← 2

console.log(true == 1 ); // true.... true → 1 === 1 ← 1

console.log(false == 0 ); // true.... false → 0 === 0 ← 0

console.log(true == "2"); // false... true → 1 !== 2 ← "2"

console.log(false == "2"); // false... false → 0 !== 2 ← "2"

console.log(true == "1"); // true.... true → 1 === 1 ← "1"

console.log(false == "0"); // true.... false → 0 === 0 ← "0"

console.log(false == "" ); // true.... false → 0 === 0 ← ""

console.log(false == NaN); // false... false → 0 !== NaN

console.log(NaN == NaN); // false...... NaN is not equivalent to

anything, including NaN.

// Type checked comparison (no conversion of types and values)

console.log(true === 1); // false...... data types do not match

// Explicit type coercion

console.log(true === !!2); // true.... data types and values match

console.log(true === !!0); // false... data types match, but values

differ

console.log( 1 ? true : false); // true.... only ±0 and NaN are "falsy"

numbers

console.log("0" ? true : false); // true.... only the empty string is

"falsy"

console.log(Boolean({})); // true.... all objects are "truthy"

The new operator can be used to create an object wrapper for a Boolean

primitive. However, the typeof operator does not return boolean for the

object wrapper, it returns object. Because all objects evaluate as true,

a method such as .valueOf(), or .toString(), must be used to retrieve

the wrapped value. For explicit coercion to the Boolean type, Mozilla

recommends that the Boolean() function (without new) be used in

preference to the Boolean object.

const b = new Boolean(false); // Object false {}

const t = Boolean(b); // Boolean true

const f = Boolean(b.valueOf()); // Boolean false

let n = new Boolean(b); // Not recommended

n = new Boolean(b.valueOf()); // Preferred

if (0 || -0 || "" || null || undefined || b.valueOf() || !new Boolean()

|| !t) {

console.log("Never this");

} else if ([] && {} && b && typeof b === "object" && b.toString() ===

"false") {

console.log("Always this");

}

Symbol

Symbols are a feature introduced in ES6. Each symbol is guaranteed to be

a unique value, and they can be used for encapsulation.cite-ref-15[15]

Example:

let x = Symbol(1);

const y = Symbol(1);

x === y; // => false

const symbolObject = {};

const normalObject = {};

// since x and y are unique,

// they can be used as unique keys in an object

symbolObject[x] = 1;

symbolObject[y] = 2;

symbolObject[x]; // => 1

symbolObject[y]; // => 2

// as compared to normal numeric keys

normalObject[1] = 1;

normalObject[1] = 2; // overrides the value of 1

normalObject[1]; // => 2

// changing the value of x does not change the key stored in the object

x = Symbol(3);

symbolObject[x]; // => undefined

// changing x back just creates another unique Symbol

x = Symbol(1);

symbolObject[x]; // => undefined

There are also well known symbols.

One of which is Symbol.iterator; if something implements

Symbol.iterator, it is iterable:

const x = [1, 2, 3, 4]; // x is an Array

x[Symbol.iterator] === Array.prototype[Symbol.iterator]; // and Arrays

are iterable

const xIterator = x[Symbol.iterator](); // The [Symbol.iterator]

function should provide an iterator for x

xIterator.next(); // { value: 1, done: false }

xIterator.next(); // { value: 2, done: false }

xIterator.next(); // { value: 3, done: false }

xIterator.next(); // { value: 4, done: false }

xIterator.next(); // { value: undefined, done: true }

// for..of loops automatically iterate values

for (const value of x) {

console.log(value); // 1 2 3 4

}

// Sets are also iterable:

[Symbol.iterator] in Set.prototype; // true

for (const value of new Set(['apple', 'orange'])) {

console.log(value); // "apple" "orange"

}

Native objects

The JavaScript language provides a handful of native objects. JavaScript

native objects are considered part of the JavaScript specification.

JavaScript environment notwithstanding, this set of objects should

always be available.

Array

An Array is a JavaScript object prototyped from the Array constructor

specifically designed to store data values indexed by integer keys.

Arrays, unlike the basic Object type, are prototyped with methods and

properties to aid the programmer in routine tasks (for example, join,

slice, and push).

As in the C family, arrays use a zero-based indexing scheme: A value

that is inserted into an empty array by means of the push method

occupies the 0th index of the array.

const myArray = []; // Point the variable myArray to a newly ...

// ... created, empty Array

myArray.push("hello World"); // Fill the next empty index, in this case

console.log(myArray[0]); // Equivalent to console.log("hello World");

Arrays have a length property that is guaranteed to always be larger

than the largest integer index used in the array. It is automatically

updated, if one creates a property with an even larger index. Writing a

smaller number to the length property will remove larger indices.

Elements of Arrays may be accessed using normal object property access

notation:

myArray[1]; // the 2nd item in myArray

myArray["1"];

The above two are equivalent. It is not possible to use the

"dot"-notation or strings with alternative representations of the

number:

myArray.1; // syntax error

myArray["01"]; // not the same as myArray[1]

Declaration of an array can use either an Array literal or the Array

constructor:

let myArray;

// Array literals

myArray = [1, 2]; // length of 2

myArray = [1, 2,]; // same array - Users can also have an extra comma at

the end

// It is also possible to not fill in parts of the array

myArray = [0, 1, /* hole */, /* hole */, 4, 5]; // length of 6

myArray = [0, 1, /* hole */, /* hole */, 4, 5,]; // same array

myArray = [0, 1, /* hole */, /* hole */, 4, 5, /* hole */,]; // length

of 7

// With the constructor

myArray = new Array(0, 1, 2, 3, 4, 5); // length of 6

myArray = new Array(365); // an empty array with length 365

Arrays are implemented so that only the defined elements use memory;

they are "sparse arrays". Setting myArray[10] = 'someThing' and

myArray[57] = 'somethingOther' only uses space for these two elements,

just like any other object. The length of the array will still be

reported as 58. The maximum length of an array is 4,294,967,295 which

corresponds to 32-bit binary number (11111111111111111111111111111111)2.

One can use the object declaration literal to create objects that behave

much like associative arrays in other languages:

const dog = {color: "brown", size: "large"};

dog["color"]; // results in "brown"

dog.color; // also results in "brown"

One can use the object and array declaration literals to quickly create

arrays that are associative, multidimensional, or both. (Technically,

JavaScript does not support multidimensional arrays, but one can mimic

them with arrays-of-arrays.)

const cats = [{color: "brown", size: "large"},

{color: "black", size: "small"}];

cats[0]["size"]; // results in "large"

const dogs = {rover: {color: "brown", size: "large"},

spot: {color: "black", size: "small"}};

dogs["spot"]["size"]; // results in "small"

dogs.rover.color; // results in "brown"

Date

A Date object stores a signed millisecond count with zero representing

1970-01-01 00:00:00 UT and a range of ±108 days. There are several ways

of providing arguments to the Date constructor. Note that months are

zero-based.

new Date(); // create a new Date instance representing the current

time/date.

new Date(2010, 2, 1); // create a new Date instance representing

2010-Mar-01 00:00:00

new Date(2010, 2, 1, 14, 25, 30); // create a new Date instance

representing 2010-Mar-01 14:25:30

new Date("2010-3-1 14:25:30"); // create a new Date instance from a

String.

Methods to extract fields are provided, as well as a useful toString:

const d = new Date(2010, 2, 1, 14, 25, 30); // 2010-Mar-01 14:25:30;

// Displays '2010-3-1 14:25:30':

console.log(d.getFullYear() + '-' + (d.getMonth() + 1) + '-' +

d.getDate() + ' '

+ d.getHours() + ':' + d.getMinutes() + ':' + d.getSeconds());

// Built-in toString returns something like 'Mon 1 March, 2010 14:25:30

GMT-0500 (EST)':

console.log(d);

Error

Custom error messages can be created using the Error class:

throw new Error("Something went wrong.");

These can be caught by try...catch...finally blocks as described in the

section on exception handling.

Math

The Math object contains various math-related constants (for example, π)

and functions (for example, cosine). (Note that the Math object has no

constructor, unlike Array or Date. All its methods are "static", that is

"class" methods.) All the trigonometric functions use angles expressed

in radians, not degrees or grads.

| Property | Returned value rounded to 5 digits | Description |

|---|---|---|

| Math.E | 2.7183 | e : Natural logarithm base |

| Math.LN2 | 0.69315 | Natural logarithm of 2 |

| Math.LN10 | 2.3026 | Natural logarithm of 10 |

| Math.LOG2E | 1.4427 | Logarithm to the base 2 of e |

| Math.LOG10E | 0.43429 | Logarithm to the base 10 of e |

| Math.PI | 3.14159 | π : circumference/diameter of a circle |

| Math.SQRT1_2 | 0.70711 | Square root of ½ |

| Math.SQRT2 | 1.4142 | Square root of 2 |

| Example | Returned value rounded to 5 digits |

|---|---|

| Math.abs(-2.3) | 2.3 |

| Math.acos(Math.SQRT1_2) | 0.78540 rad = 45° |

| Math.asin(Math.SQRT1_2) | 0.78540 rad = 45° |

| Math.atan(1) | 0.78540 rad = 45° |

| Math.atan2(-3.7, -3.7) | −2.3562 rad = −135° |

| Math.ceil(1.1) | 2 |

| Math.cos(Math.PI/4) | 0.70711 |

| Math.exp(1) | 2.7183 |

| Math.floor(1.9) | 1 |

| Math.log(Math.E) | 1 |

| Math.max(1, -2) | 1 |

| Math.min(1, -2) | −2 |

| Math.pow(-3, 2) | 9 |

| Math.random() | e.g. 0.17068 |

| Math.round(1.5) | 2 |

| Math.sin(Math.PI/4) | 0.70711 |

| Math.sqrt(49) | 7 |

| Math.tan(Math.PI/4) | 1 |

| Example | Description |

|---|---|

| Math.abs(-2.3) | Absolute value |

| Math.acos(Math.SQRT1_2) | Arccosine |

| Math.asin(Math.SQRT1_2) | Arcsine |

| Math.atan(1) | Half circle arctangent ( ⁠ − π / 2 {\d… |

| Math.atan2(-3.7, -3.7) | Whole circle arctangent ( ⁠ − π {\disp… |

| Math.ceil(1.1) | Ceiling: round up to smallest integer ≥… |

| Math.cos(Math.PI/4) | Cosine |

| Math.exp(1) | Exponential function : e raised to this… |

| Math.floor(1.9) | Floor: round down to largest integer ≤… |

| Math.log(Math.E) | Natural logarithm, base e |

| Math.max(1, -2) | Maximum: (x > y) ? x : y |

| Math.min(1, -2) | Minimum: (x < y) ? x : y |

| Math.pow(-3, 2) | Exponentiation (raised to the power of)… |

| Math.random() | Pseudorandom number between 0 (inclusiv… |

| Math.round(1.5) | Round to the nearest integer; half frac… |

| Math.sin(Math.PI/4) | Sine |

| Math.sqrt(49) | Square root |

| Math.tan(Math.PI/4) | Tangent |

Regular expression

/expression/.test(string); // returns Boolean

"string".search(/expression/); // returns position Number

"string".replace(/expression/, replacement);

// Here are some examples

if (/Tom/.test("My name is Tom")) console.log("Hello Tom!");

console.log("My name is Tom".search(/Tom/)); // == 11 (letters before

Tom)

console.log("My name is Tom".replace(/Tom/, "John")); // == "My name is

John"

Character classes

// \d - digit

// \D - non digit

// \s - space

// \S - non space

// \w - word char

// \W - non word

// [ ] - one of

// [^] - one not of

// - - range

if (/\d/.test('0')) console.log('Digit');

if (/[0-9]/.test('6')) console.log('Digit');

if (/[13579]/.test('1')) console.log('Odd number');

if (/\S\S\s\S\S\S\S/.test('My name')) console.log('Format OK');

if (/\w\w\w/.test('Tom')) console.log('Hello Tom');

if (/[a-zA-Z]/.test('B')) console.log('Letter');

Character matching

// A...Z a...z 0...9 - alphanumeric

// \u0000...\uFFFF - Unicode hexadecimal

// \x00...\xFF - ASCII hexadecimal

// \t - tab

// \n - new line

// \r - CR

// . - any character

// | - OR

if (/T.m/.test('Tom')) console.log ('Hi Tom, Tam or Tim');

if (/A|B/.test("A")) console.log ('A or B');

Repeaters

// ? - 0 or 1 match

// * - 0 or more

// + - 1 or more

// {n} - exactly n

// {n,} - n or more

// {0,n} - n or less

// {n,m} - range n to m

if (/ab?c/.test("ac")) console.log("OK"); // match: "ac", "abc"

if (/ab*c/.test("ac")) console.log("OK"); // match: "ac", "abc", "abbc",

"abbbc" etc.

if (/ab+c/.test("abc")) console.log("OK"); // match: "abc", "abbc",

"abbbc" etc.

if (/ab{3}c/.test("abbbc")) console.log("OK"); // match: "abbbc"

if (/ab{3,}c/.test("abbbc")) console.log("OK"); // match: "abbbc",

"abbbbc", "abbbbbc" etc.

if (/ab{1,3}c/.test("abc")) console.log("OK"); // match: "abc", "abbc",

"abbbc"

Anchors

// ^ - string starts with

// $ - string ends with

if (/^My/.test("My name is Tom")) console.log ("Hi!");

if (/Tom$/.test("My name is Tom")) console.log ("Hi Tom!");

Subexpression

// ( ) - groups characters

if (/water(mark)?/.test("watermark")) console.log("Here is water!"); //

match: "water", "watermark",

if (/(Tom)|(John)/.test("John")) console.log("Hi Tom or John!");

Flags

// /g - global

// /i - ignore upper/lower case

// /m - allow matches to span multiple lines

console.log("hi tom!".replace(/Tom/i, "John")); // == "hi John!"

console.log("ratatam".replace(/ta/, "tu")); // == "ratutam"

console.log("ratatam".replace(/ta/g, "tu")); // == "ratutum"

Advanced methods

my_array = my_string.split(my_delimiter);

// example

my_array = "dog,cat,cow".split(","); // my_array==["dog","cat","cow"];

my_array = my_string.match(my_expression);

// example

my_array = "We start at 11:30, 12:15 and 16:45".match(/\d\d:\d\d/g);

// my_array==["11:30","12:15","16:45"];

Capturing groups

const myRe = /(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})/;

const results = myRe.exec("The date and time are 2009-09-08 09:37:08.");

if (results) {

console.log("Matched: " + results[0]); // Entire match

const my_date = results[1]; // First group == "2009-09-08"

const my_time = results[2]; // Second group == "09:37:08"

console.log(`It is ${my_time} on ${my_date}`);

} else console.log("Did not find a valid date!");

Function

Every function in JavaScript is an instance of the Function constructor:

// x, y is the argument. 'return x + y' is the function body, which is

the last in the argument list.

const add = new Function('x', 'y', 'return x + y');

add(1, 2); // => 3

The add function above may also be defined using a function expression:

const add = function(x, y) {

return x + y;

};

add(1, 2); // => 3

In ES6, arrow function syntax was added, allowing functions that return

a value to be more concise. They also retain the this of the global

object instead of inheriting it from where it was called / what it was

called on, unlike the function() {} expression.

const add = (x, y) => {return x + y;};

// values can also be implicitly returned (i.e. no return statement is

needed)

const addImplicit = (x, y) => x + y;

add(1, 2); // => 3

addImplicit(1, 2) // => 3

For functions that need to be hoisted, there is a separate expression:

function add(x, y) {

return x + y;

}

add(1, 2); // => 3

Hoisting allows users to use the function before it is "declared":

add(1, 2); // => 3, not a ReferenceError

function add(x, y) {

return x + y;

}

A function instance has properties and methods.

function subtract(x, y) {

return x - y;

}

console.log(subtract.length); // => 2, arity of the function (number of

arguments)

console.log(subtract.toString());

"function subtract(x, y) {

return x - y;

Operators

The '+' operator is overloaded: it is used for string concatenation and

arithmetic addition. This may cause problems when inadvertently mixing

strings and numbers. As a unary operator, it can convert a numeric

string to a number.

// Concatenate 2 strings

console.log('He' + 'llo'); // displays Hello

// Add two numbers

console.log(2 + 6); // displays 8

// Adding a number and a string results in concatenation (from left to

right)

console.log(2 + '2'); // displays 22

console.log('$' + 3 + 4); // displays $34, but $7 may have been expected

console.log('$' + (3 + 4)); // displays $7

console.log(3 + 4 + '7'); // displays 77, numbers stay numbers until a

string is added

// Convert a string to a number using the unary plus

console.log(+'2' === 2); // displays true

console.log(+'Hello'); // displays NaN

Similarly, the '*' operator is overloaded: it can convert a string into

a number.

console.log(2 + '6'*1); // displays 8

console.log(3*'7'); // 21

console.log('3'*'7'); // 21

console.log('hello'*'world'); // displays NaN

Arithmetic

JavaScript supports the following binary arithmetic operators:

| + | addition |

|---|---|

| - | subtraction |

| * | multiplication |

| / | division (returns a floating-point valu… |

| % | modulo (returns the remainder) |

| ** | exponentiation |

JavaScript supports the following unary arithmetic operators:

| + | unary conversion of string to number |

|---|---|

| - | unary negation (reverses the sign) |

| ++ | increment (can be prefix or postfix) |

| -- | decrement (can be prefix or postfix) |

let x = 1;

console.log(++x); // x becomes 2; displays 2

console.log(x++); // displays 2; x becomes 3

console.log(x); // x is 3; displays 3

console.log(x--); // displays 3; x becomes 2

console.log(x); // displays 2; x is 2

console.log(--x); // x becomes 1; displays 1

The modulo operator displays the remainder after division by the

modulus. If negative numbers are involved, the returned value depends on

the operand.

const x = 17;

console.log(x%5); // displays 2

console.log(x%6); // displays 5

console.log(-x%5); // displays -2

console.log(-x%-5); // displays -2

console.log(x%-5); // displays 2

To always return a non-negative number, users can re-add the modulus and

apply the modulo operator again:

const x = 17;

console.log((-x%5+5)%5); // displays 3

Users could also do:

const x = 17;

console.log(Math.abs(-x%5)); // also 3

Assignment

| = | assign |

|---|---|

| += | add and assign |

| -= | subtract and assign |

| *= | multiply and assign |

| /= | divide and assign |

| %= | modulo and assign |

| **= | exponentiation and assign |

Assignment of primitive types

let x = 9;

x += 1;

console.log(x); // displays: 10

x *= 30;

console.log(x); // displays: 300

x /= 6;

console.log(x); // displays: 50

x -= 3;

console.log(x); // displays: 47

x %= 7;

console.log(x); // displays: 5

Assignment of object types

/**

* To learn JavaScript objects...

const object_1 = {a: 1}; // assign reference of newly created object to

object_1

let object_2 = {a: 0};

let object_3 = object_2; // object_3 references the same object as

object_2 does

object_3.a = 2;

message(); // displays 1 2 2

object_2 = object_1; // object_2 now references the same object as

object_1

// object_3 still references what object_2 referenced before

message(); // displays 1 1 2

object_2.a = 7; // modifies object_1

message(); // displays 7 7 2

object_3.a = 5; // object_3 does not change object_2

message(); // displays 7 7 5

object_3 = object_2;

object_3.a=4; // object_3 changes object_1 and object_2

message(); // displays 4 4 4

/**

* Prints the console.log message

function message() {

console.log(object_1.a + " " + object_2.a + " " + object_3.a);

}

Destructuring assignment

In Mozilla's JavaScript, since version 1.7, destructuring assignment

allows the assignment of parts of data structures to several variables

at once. The left hand side of an assignment is a pattern that resembles

an arbitrarily nested object/array literal containing l-lvalues at its

leaves that are to receive the substructures of the assigned value.

let a, b, c, d, e;

[a, b, c] = [3, 4, 5];

console.log(`${a},${b},${c}`); // displays: 3,4,5

e = {foo: 5, bar: 6, baz: ['Baz', 'Content']};

const arr = [];

({baz: [arr[0], arr[3]], foo: a, bar: b} = e);

console.log(`${a},${b},${arr}`); // displays: 5,6,Baz,,,Content

[a, b] = [b, a]; // swap contents of a and b

console.log(a + ',' + b); // displays: 6,5

[a, b, c] = [3, 4, 5]; // permutations

[a, b, c] = [b, c, a];

console.log(`${a},${b},${c}`); // displays: 4,5,3

Spread/rest operator

The ECMAScript 2015 standard introduced the "..." array operator, for

the related concepts of "spread syntax"cite-ref-16[16] and "rest parameters".cite-ref-17[17]

Object spreading was added in ECMAScript 2018.

Spread syntax provides another way to destructure arrays and objects.

For arrays, it indicates that the elements should be used as the

parameters in a function call or the items in an array literal. For

objects, it can be used for merging objects together or overriding

properties.

In other words, "..." transforms "[...foo]" into "[foo[0], foo[1],

foo[2]]", and "this.bar(...foo);" into "this.bar(foo[0], foo[1],

foo[2]);", and "{ ...bar }" into { prop: bar.prop, prop2: bar.prop2 }.

const a = [1, 2, 3, 4];

// It can be used multiple times in the same expression

const b = [...a, ...a]; // b = [1, 2, 3, 4, 1, 2, 3, 4];

// It can be combined with non-spread items.

const c = [5, 6, ...a, 7, 9]; // c = [5, 6, 1, 2, 3, 4, 7, 9];

// For comparison, doing this without the spread operator

// creates a nested array.

const d = [a, a]; // d = [[1, 2, 3, 4], [1, 2, 3, 4]]

// It works the same with function calls

function foo(arg1, arg2, arg3) {

console.log(`${arg1}:${arg2}:${arg3}`);

}

// Users can use it even if it passes more parameters than the function

will use

foo(...a); // "1:2:3" → foo(a[0], a[1], a[2], a[3]);

// Users can mix it with non-spread parameters

foo(5, ...a, 6); // "5:1:2" → foo(5, a[0], a[1], a[2], a[3], 6);

// For comparison, doing this without the spread operator

// assigns the array to arg1, and nothing to the other parameters.

foo(a); // "1,2,3,4:undefined:undefined"

const bar = { a: 1, b: 2, c: 3 };

// This would copy the object

const copy = { ...bar }; // copy = { a: 1, b: 2, c: 3 };

// "b" would be overridden here

const override = { ...bar, b: 4 }; // override = { a: 1, c: 3, b: 4 }

When ... is used in a function declaration, it indicates a rest

parameter. The rest parameter must be the final named parameter in the

function's parameter list. It will be assigned an Array containing any

arguments passed to the function in excess of the other named

parameters. In other words, it gets "the rest" of the arguments passed

to the function (hence the name).

function foo(a, b, ...c) {

console.log(c.length);

}

foo(1, 2, 3, 4, 5); // "3" → c = [3, 4, 5]

foo('a', 'b'); // "0" → c = []

Rest parameters are similar to Javascript's arguments object, which is

an array-like object that contains all of the parameters (named and

unnamed) in the current function call. Unlike arguments, however, rest

parameters are true Array objects, so methods such as .slice() and

.sort() can be used on them directly.

Comparison

| == | equal |

|---|---|

| != | not equal |

| > | greater than |

| >= | greater than or equal to |

| < | less than |

| <= | less than or equal to |

| === | identical (equal and of same type) |

| !== | not identical |

Variables referencing objects are equal or identical only if they

reference the same object:

const obj1 = {a: 1};

const obj2 = {a: 1};

const obj3 = obj1;

console.log(obj1 == obj2); //false

console.log(obj3 == obj1); //true

console.log(obj3 === obj1); //true

See also String.

Logical

JavaScript provides four logical operators:

• unary negation (NOT = !a)

• binary disjunction (OR = a || b) and conjunction (AND = a && b)

• ternary conditional (c ? t : f)

In the context of a logical operation, any expression evaluates to true

except the following:

• Strings: "", '',

• Numbers: 0, -0, NaN,

• Special: null, undefined,

• Boolean: false.

The Boolean function can be used to explicitly convert to a primitive of

type Boolean:

// Only empty strings return false

console.log(Boolean("") === false);

console.log(Boolean("false") === true);

console.log(Boolean("0") === true);

// Only zero and NaN return false

console.log(Boolean(NaN) === false);

console.log(Boolean(0) === false);

console.log(Boolean(-0) === false); // equivalent to -1*0

console.log(Boolean(-2) === true);

// All objects return true

console.log(Boolean(this) === true);

console.log(Boolean({}) === true);

console.log(Boolean([]) === true);

// These types return false

console.log(Boolean(null) === false);

console.log(Boolean(undefined) === false); // equivalent to Boolean()

The NOT operator evaluates its operand as a Boolean and returns the

negation. Using the operator twice in a row, as a double negative,

explicitly converts an expression to a primitive of type Boolean:

console.log( !0 === Boolean(!0));

console.log(Boolean(!0) === !!1);

console.log(!!1 === Boolean(1));

console.log(!!0 === Boolean(0));

console.log(Boolean(0) === !1);

console.log(!1 === Boolean(!1));

console.log(!"" === Boolean(!""));

console.log(Boolean(!"") === !!"s");

console.log(!!"s" === Boolean("s"));

console.log(!!"" === Boolean(""));

console.log(Boolean("") === !"s");

console.log(!"s" === Boolean(!"s"));

The ternary operator can also be used for explicit conversion:

console.log([] == false); console.log([] ? true : false); // “truthy”,

but the comparison uses [].toString()

console.log([0] == false); console.log([0]? true : false); //

[0].toString() == "0"

console.log("0" == false); console.log("0"? true : false); // "0" → 0

... (0 == 0) ... 0 ← false

console.log([1] == true); console.log([1]? true : false); //

[1].toString() == "1"

console.log("1" == true); console.log("1"? true : false); // "1" → 1 ...

(1 == 1) ... 1 ← true

console.log([2] != true); console.log([2]? true : false); //

[2].toString() == "2"

console.log("2" != true); console.log("2"? true : false); // "2" → 2 ...

(2 != 1) ... 1 ← true

Expressions that use features such as post–incrementation (i++) have an

anticipated side effect. JavaScript provides short-circuit evaluation of

expressions; the right operand is only executed if the left operand does

not suffice to determine the value of the expression.

console.log(a || b); // When a is true, there is no reason to evaluate

console.log(a && b); // When a is false, there is no reason to evaluate

console.log(c ? t : f); // When c is true, there is no reason to

evaluate f.

In early versions of JavaScript and JScript, the binary logical

operators returned a Boolean value (like most C-derived programming

languages). However, all contemporary implementations return one of

their operands instead:

console.log(a || b); // if a is true, return a, otherwise return b

console.log(a && b); // if a is false, return a, otherwise return b

Programmers who are more familiar with the behavior in C might find this

feature surprising, but it allows for a more concise expression of

patterns like null coalescing:

const s = t || "(default)"; // assigns t, or the default value, if t is

null, empty, etc.

Logical assignment

| ??= | Nullish assignment |

|---|---|

| //= | Logical Or assignment |

| &&= | Logical And assignment |

Bitwise

JavaScript supports the following binary bitwise operators:

| & | AND |

|---|---|

| / | OR |

| ^ | XOR |

| ! | NOT |

| << | shift left (zero fill at right) |

| >> | shift right (sign-propagating); copies… |

| >>> | shift right (zero fill at left). For po… |

Examples:

const x = 11 & 6;

console.log(x); // 2

JavaScript supports the following unary bitwise operator:

Bitwise Assignment

JavaScript supports the following binary assignment operators:

| &= | and |

|---|---|

| /= | or |

| ^= | xor |

| <<= | shift left (zero fill at right) |

| >>= | shift right (sign-propagating); copies… |

| >>>= | shift right (zero fill at left). For po… |

Examples:

let x=7;

console.log(x); // 7

x<<=3;

console.log(x); // 7->14->28->56

String

| = | assignment |

|---|---|

| + | concatenation |

| += | concatenate and assign |

Examples:

let str = "ab" + "cd"; // "abcd"

str += "e"; // "abcde"

const str2 = "2" + 2; // "22", not "4" or 4.

JavaScript's nearest operator is ??, the "nullish coalescing operator",

which was added to the standard in ECMAScript's 11th edition.cite-ref-18[18] In

earlier versions, it could be used via a Babel plugin, and in

TypeScript. It evaluates its left-hand operand and, if the result value

is not "nullish" (null or undefined), takes that value as its result;

otherwise, it evaluates the right-hand operand and takes the resulting

value as its result.

In the following example, a will be assigned the value of b if the value

of b is not null or undefined, otherwise it will be assigned 3.

const a = b ?? 3;

Before the nullish coalescing operator, programmers would use the

logical OR operator (||). But where ?? looks specifically for null or

undefined, the || operator looks for any falsy value: null, undefined,

"", 0, NaN, and of course, false.

In the following example, a will be assigned the value of b if the value

of b is truthy, otherwise it will be assigned 3.

const a = b || 3;

Control structures

Compound statements

A pair of curly brackets { } and an enclosed sequence of statements

constitute a compound statement, which can be used wherever a statement

can be used.

If ... else

if (expr) {

//statements;

} else if (expr2) {

//statements;

} else {

//statements;

}

Conditional (ternary) operator

The conditional operator creates an expression that evaluates as one of

two expressions depending on a condition. This is similar to the if

statement that selects one of two statements to execute depending on a

condition. I.e., the conditional operator is to expressions what if is

to statements.

const result = condition ? expression : alternative;

is the same as:

if (condition) {

const result = expression;

} else {

const result = alternative;

}

Unlike the if statement, the conditional operator cannot omit its

"else-branch".

Switch statement

The syntax of the JavaScript switch statement is as follows:

switch (expr) {

case SOMEVALUE:

// statements;

break;

case ANOTHERVALUE:

// statements for when ANOTHERVALUE || ORNAOTHERONE

// no break statement, falling through to the following case

case ORANOTHERONE:

// statements specific to ORANOTHERONE (i.e. !ANOTHERVALUE &&

ORANOTHER);

break; //The buck stops here.

case YETANOTHER:

// statements;

break;

default:

// statements;

break;

}

• break; is optional; however, it is usually needed, since otherwise

code execution will continue to the body of the next case block. This

fall through behavior can be used when the same set of statements apply

in several cases, effectively creating a disjunction between those

cases.

• Add a break statement to the end of the last case as a precautionary

measure, in case additional cases are added later.

• String literal values can also be used for the case values.

• Expressions can be used instead of values.

• The default case (optional) is executed when the expression does not

match any other specified cases.

• Braces are required.

For loop

The syntax of the JavaScript for loop is as follows:

for (initial; condition; loop statement) {

statements will be executed every time

the for{} loop cycles, while the

condition is satisfied

}

for (initial; condition; loop statement(iteration)) // one statement

For ... in loop

The syntax of the JavaScript for ... in loop is as follows:

for (var property_name in some_object) {

// statements using some_object[property_name];

}

• Iterates through all enumerable properties of an object.

• Iterates through all used indices of array including all user-defined

properties of array object, if any. Thus it may be better to use a

traditional for loop with a numeric index when iterating over arrays.

• There are differences between the various Web browsers with regard to

which properties will be reflected with the for...in loop statement. In

theory, this is controlled by an internal state property defined by the

ECMAscript standard called "DontEnum", but in practice, each browser

returns a slightly different set of properties during introspection. It

is useful to test for a given property using if

(some_object.hasOwnProperty(property_name)) { ... }. Thus, adding a

method to the array prototype with Array.prototype.newMethod =

function() {...} may cause for ... in loops to loop over the method's

name.

While loop

The syntax of the JavaScript while loop is as follows:

while (condition) {

statement1;

statement2;

statement3;

...

}

Do ... while loop

The syntax of the JavaScript do ... while loop is as follows:

do {

statement1;

statement2;

statement3;

...

} while (condition);

With

The with statement adds all of the given object's properties and methods

into the following block's scope, letting them be referenced as if they

were local variables.

with (document) {

const a = getElementById('a');

const b = getElementById('b');

const c = getElementById('c');

};

• Note the absence of document. before each getElementById() invocation.

The semantics are similar to the with statement of Pascal.

Because the availability of with statements hinders program performance

and is believed to reduce code clarity (since any given variable could

actually be a property from an enclosing with), this statement is not

allowed in strict mode.

Labels

JavaScript supports nested labels in most implementations. Loops or

blocks can be labeled for the break statement, and loops for continue.

Although goto is a reserved word,cite-ref-19[19] goto is not implemented in

JavaScript.

loop1: for (let a = 0; a < 10; ++a) {

if (a === 4) break loop1; // Stops after the 4th attempt

console.log('a = ' + a);

loop2: for (let b = 0; b < 10; ++b) {

if (b === 3) continue loop2; // Number 3 is skipped

if (b === 6) continue loop1; // Continues the first loop, 'finished' is

not shown

console.log('b = ' + b);

} //end of loop2

console.log('finished');

} //end of loop1

block1: {

console.log('Hello'); // Displays 'Hello'

break block1;

console.log('World'); // Will never get here

}

goto block1; // Parse error.

Functions

A function is a block with a (possibly empty) parameter list that is

normally given a name. A function may use local variables. If a user

exits the function without a return statement, the value undefined is

returned.

function gcd(number1, number2) {

if (isNaN(number1*number2)) throw TypeError("Non-Numeric arguments not

allowed.");

number1 = Math.round(number1);

number2 = Math.round(number2);

let difference = number1 - number2;

if (difference === 0) return number1;

return difference > 0 ? gcd(number2, difference) : gcd(number1,

difference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`bdifference);`f`b

}

console.log(gcd(60, 40)); // 20

//In the absence of parentheses following the identifier 'gcd' on the

RHS of the assignment below,

//'gcd' returns a reference to the function itself without invoking it.

let mygcd = gcd; // mygcd and gcd reference the same function.

console.log(mygcd(60, 40)); // 20

Functions are first class objects and may be assigned to other

variables.

The number of arguments given when calling a function may not

necessarily correspond to the number of arguments in the function

definition; a named argument in the definition that does not have a

matching argument in the call will have the value undefined (that can be

implicitly cast to false). Within the function, the arguments may also

be accessed through the arguments object; this provides access to all

arguments using indices (e.g. arguments[0], arguments[1], ...

arguments[n]), including those beyond the number of named arguments.

(While the arguments list has a .length property, it is not an instance

of Array; it does not have methods such as .slice(), .sort(), etc.)

function add7(x, y) {

if (!y) {

y = 7;

}

console.log(x + y + arguments.length);

};

add7(3); // 11

add7(3, 4); // 9

Primitive values (number, boolean, string) are passed by value. For

objects, it is the reference to the object that is passed.

const obj1 = {a : 1};

const obj2 = {b : 2};

function foo(p) {

p = obj2; // Ignores actual parameter

p.b = arguments[1];

}

foo(obj1, 3); // Does not affect obj1 at all. 3 is additional parameter

console.log(`${obj1.a} ${obj2.b}`); // writes 1 3

Functions can be declared inside other functions, and access the outer

function's local variables. Furthermore, they implement full closures by

remembering the outer function's local variables even after the outer

function has exited.

let t = "Top";

let bar, baz;

function foo() {

let f = "foo var";

bar = function() { console.log(f) };

baz = function(x) { f = x; };

}

foo();

baz("baz arg");

bar(); // "baz arg" (not "foo var") even though foo() has exited.

console.log(t); // Top

An anonymous function is simply a function without a name and can be

written either using function or arrow notation. In these equivalent

examples an anonymous function is passed to the map function and is

applied to each of the elements of the array.cite-ref-20[20]

[1,2,3].map(function(x) { return x*2;); //returns [2,4,6]

[1,2,3].map((x) => { return x*2;}); //same result

A generator function is signified placing an * after the keyword

function and contains one or more yield statements. The effect is to

return a value and pause execution at the current state. Declaring an

generator function returns an iterator. Subsequent calls to

iterator.next() resumes execution until the next yield. When the

iterator returns without using a yield statement there are no more

values and the done property of the iterator is set to true.cite-ref-21[21]

With the exception of iOS devices from Apple, generators are not

implemented for browsers on mobile devices. cite-ref-22[22]

function* generator() {

yield "red";

yield "green";

yield "blue";

}

let iterator=generator();

let current;

while(current=iterator.next().value)

console.log(current); //displays red, green then blue

console.log(iterator.next().done) //displays true

Async/await

The await operator in JavaScript can only be used from inside an async

function or at the top level of a module. If the parameter is a promise,

execution of the async function will resume when the promise is resolved

(unless the promise is rejected, in which case an error will be thrown

that can be handled with normal JavaScript exception handling). If the

parameter is not a promise, the parameter itself will be returned

immediately.cite-ref-23[23]

Many libraries provide promise objects that can also be used with await,

as long as they match the specification for native JavaScript promises.

However, promises from the jQuery library were not Promises/A+

compatible until jQuery 3.0.cite-ref-24[24]

Below is an example (modified from thiscite-ref-async-await-javascript-async-await-25-0[25] article):

async function createNewDoc() {

let response = await db.post({}); // post a new doc

return db.get(response.id); // find by id

}

async function main() {

try {

let doc = await createNewDoc();

console.log(doc);

} catch (err) {

console.log(err);

}

main();

Node.js

version 8 includes a utility that enables using the standard library

callback-based methods as promises.

Objects

For convenience, types are normally subdivided into primitives and

objects. Objects are entities that have an identity (they are only equal

to themselves) and that map property names to values ("slots" in

prototype-based programming terminology). Objects may be thought of as

associative arrays or hashes, and are often implemented using these data

structures. However, objects have additional features, such as a

prototype chain, which ordinary associative arrays do not have.

JavaScript has several kinds of built-in objects, namely Array, Boolean,

Date, Function, Math, Number, Object, RegExp and String. Other objects

are "host objects", defined not by the language, but by the runtime

environment. For example, in a browser, typical host objects belong to

the DOM (window, form, links, etc.).

Creating objects

Objects can be created using a constructor or an object literal. The

constructor can use either a built-in Object function or a custom

function. It is a convention that constructor functions are given a name

that starts with a capital letter:

// Constructor

const anObject = new Object();

// Object literal

const objectA = {};

const objectA2 = {}; // A != A2, {}s create new objects as copies.

const objectB = {index1: 'value 1', index2: 'value 2'};

// Custom constructor (see below)

Object literals and array literals allow one to easily create flexible

data structures:

const myStructure = {

name: {

first: "Mel",

last: "Smith"

age: 33,

hobbies: ["chess", "jogging"]

};

This is the basis for JSON, which is a simple notation that uses

JavaScript-like syntax for data exchange.

Methods

A method is simply a function that has been assigned to a property name

of an object. Unlike many object-oriented languages, there is no

distinction between a function definition and a method definition in

object-related JavaScript. Rather, the distinction occurs during

function calling; a function can be called as a method.

When called as a method, the standard local variable this is just

automatically set to the object instance to the left of the ".". (There

are also call and apply methods that can set this explicitly—some

packages such as jQuery do unusual things with this.)

In the example below, Foo is being used as a constructor. There is

nothing special about a constructor - it is just a plain function that

initializes an object. When used with the new keyword, as is the norm,

this is set to a newly created blank object.

Note that in the example below, Foo is simply assigning values to slots,

some of which are functions. Thus it can assign different functions to

different instances. There is no prototyping in this example.

function px() { return this.prefix + "X"; }

function Foo(yz) {

this.prefix = "a-";

if (yz > 0) {

this.pyz = function() { return this.prefix + "Y"; };

} else {

this.pyz = function() { return this.prefix + "Z"; };

}

this.m1 = px;

return this;

}

const foo1 = new Foo(1);

const foo2 = new Foo(0);

foo2.prefix = "b-";

console.log("foo1/2 " + foo1.pyz() + foo2.pyz());

// foo1/2 a-Y b-Z

foo1.m3 = px; // Assigns the function itself, not its evaluated result,

i.e. not px()

const baz = {"prefix": "c-"};

baz.m4 = px; // No need for a constructor to make an object.

console.log("m1/m3/m4 " + foo1.m1() + foo1.m3() + baz.m4());

// m1/m3/m4 a-X a-X c-X

foo1.m2(); // Throws an exception, because foo1.m2 does not exist.

Constructors

Constructor functions simply assign values to slots of a newly created

object. The values may be data or other functions.

Example: Manipulating an object:

function MyObject(attributeA, attributeB) {

this.attributeA = attributeA;

this.attributeB = attributeB;

}

MyObject.staticC = "blue"; // On MyObject Function, not object

console.log(MyObject.staticC); // blue

const object = new MyObject('red', 1000);

console.log(object.attributeA); // red

console.log(object.attributeB); // 1000

console.log(object.staticC); // undefined

object.attributeC = new Date(); // add a new property

delete object.attributeB; // remove a property of object

console.log(object.attributeB); // undefined

The constructor itself is referenced in the object's prototype's

constructor slot. So,

function Foo() {}

// Use of 'new' sets prototype slots (for example,

// x = new Foo() would set x's prototype to Foo.prototype,

// and Foo.prototype has a constructor slot pointing back to Foo).

const x = new Foo();

// The above is almost equivalent to

const y = {};

y.constructor = Foo;

y.constructor();

// Except

x.constructor == y.constructor; // true

x instanceof Foo; // true

y instanceof Foo; // false

// y's prototype is Object.prototype, not

// Foo.prototype, since it was initialized with

// {} instead of new Foo.

// Even though Foo is set to y's constructor slot,

// this is ignored by instanceof - only y's prototype's

// constructor slot is considered.

Functions are objects themselves, which can be used to produce an effect

similar to "static properties" (using C++/Java terminology) as shown

below. (The function object also has a special prototype property, as

discussed in the "Inheritance" section below.)

Object deletion is rarely used as the scripting engine will

garbage collect objects that are no longer being referenced.

Inheritance

JavaScript supports inheritance hierarchies through prototyping in the

manner of Self.

In the following example, the Derived class inherits from the Base

class. When d is created as Derived, the reference to the base instance

of Base is copied to d.base.

Derive does not contain a value for aBaseFunction, so it is retrieved

from aBaseFunction when aBaseFunction is accessed. This is made clear by

changing the value of base.aBaseFunction, which is reflected in the

value of d.aBaseFunction.

Some implementations allow the prototype to be accessed or set

explicitly using the __proto__ slot as shown below.

function Base() {

this.anOverride = function() { console.log("Base::anOverride()"); };

this.aBaseFunction = function() { console.log("Base::aBaseFunction()");

};

}

function Derived() {

this.anOverride = function() { console.log("Derived::anOverride()"); };

}

const base = new Base();

Derived.prototype = base; // Must be before new Derived()

Derived.prototype.constructor = Derived; // Required to make

`instanceof` work

const d = new Derived(); // Copies Derived.prototype to d instance's

hidden prototype slot.

d instanceof Derived; // true

d instanceof Base; // true

base.aBaseFunction = function() {

console.log("Base::aNEWBaseFunction()"); };

d.anOverride(); // Derived::anOverride()

d.aBaseFunction(); // Base::aNEWBaseFunction()

console.log(d.aBaseFunction == Derived.prototype.aBaseFunction); // true

console.log(d.__proto__ == base); // true in Mozilla-based

implementations and false in many others.

The following shows clearly how references to prototypes are copied on

instance creation, but that changes to a prototype can affect all

instances that refer to it.

function m1() { return "One"; }

function m2() { return "Two"; }

function m3() { return "Three"; }

function Base() {}

Base.prototype.m = m2;

const bar = new Base();

console.log("bar.m " + bar.m()); // bar.m Two

function Top() { this.m = m3; }

const t = new Top();

const foo = new Base();

Base.prototype = t;

// No effect on foo, the *reference* to t is copied.

console.log("foo.m " + foo.m()); // foo.m Two

const baz = new Base();

console.log("baz.m " + baz.m()); // baz.m Three

t.m = m1; // Does affect baz, and any other derived classes.

console.log("baz.m1 " + baz.m()); // baz.m1 One

In practice many variations of these themes are used, and it can be both

powerful and confusing.

Exception handling

JavaScript includes a try ... catch ... finally exception handling

statement to handle run-time errors.

The try ... catch ... finally statement catches exceptions resulting

from an error or a throw statement. Its syntax is as follows:

try {

// Statements in which exceptions might be thrown

} catch(errorValue) {

// Statements that execute in the event of an exception

} finally {

// Statements that execute afterward either way

}

Initially, the statements within the try block execute. If an exception

is thrown, the script's control flow immediately transfers to the

statements in the catch block, with the exception available as the error

argument. Otherwise the catch block is skipped. The catch block can

throw(errorValue), if it does not want to handle a specific error.

In any case the statements in the finally block are always executed.

This can be used to free resources, although memory is automatically

garbage collected.

Either the catch or the finally clause may be omitted. The catch

argument is required.

The Mozilla implementation allows for multiple catch statements, as an

extension to the ECMAScript standard. They follow a syntax similar to

that used in Java:

try { statement; }

catch (e if e == "InvalidNameException") { statement; }

catch (e if e == "InvalidIdException") { statement; }

catch (e if e == "InvalidEmailException") { statement; }

catch (e) { statement; }

In a browser, the onerror event is more commonly used to trap

exceptions.

onerror = function (errorValue, url, lineNr) {...; return true;};

Native functions and methods

eval (expression)

Evaluates the first parameter as an expression, which can include

assignment statements. Variables local to functions can be referenced by

the expression. However, eval represents a major security risk, as it

allows a bad actor to execute arbitrary code, so its use is

discouraged.cite-ref-deve-eval-27-0[27]

> (function foo() {

... var x = 7;

... console.log("val " + eval("x + 2"));

... })();

val 9

undefined